{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "fTFj8ft5dlbS"
      },
      "source": [
        "##### Copyright 2018 The TensorFlow Authors."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "colab": {},
        "colab_type": "code",
        "id": "lzyBOpYMdp3F"
      },
      "outputs": [],
      "source": [
        "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "# you may not use this file except in compliance with the License.\n",
        "# You may obtain a copy of the License at\n",
        "#\n",
        "# https://www.apache.org/licenses/LICENSE-2.0\n",
        "#\n",
        "# Unless required by applicable law or agreed to in writing, software\n",
        "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "# See the License for the specific language governing permissions and\n",
        "# limitations under the License."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "colab": {},
        "colab_type": "code",
        "id": "m_x4KfSJ7Vt7"
      },
      "outputs": [],
      "source": [
        "#@title MIT License\n",
        "#\n",
        "# Copyright (c) 2017 François Chollet\n",
        "#\n",
        "# Permission is hereby granted, free of charge, to any person obtaining a\n",
        "# copy of this software and associated documentation files (the \"Software\"),\n",
        "# to deal in the Software without restriction, including without limitation\n",
        "# the rights to use, copy, modify, merge, publish, distribute, sublicense,\n",
        "# and/or sell copies of the Software, and to permit persons to whom the\n",
        "# Software is furnished to do so, subject to the following conditions:\n",
        "#\n",
        "# The above copyright notice and this permission notice shall be included in\n",
        "# all copies or substantial portions of the Software.\n",
        "#\n",
        "# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n",
        "# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n",
        "# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\n",
        "# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n",
        "# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n",
        "# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n",
        "# DEALINGS IN THE SOFTWARE."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "C9HmC2T4ld5B"
      },
      "source": [
        "# Khám phá Overfitting và Underfitting"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "kRTxFhXAlnl1"
      },
      "source": [
        "<table class=\"tfo-notebook-buttons\" align=\"left\">\n",
        "  <td>\n",
        "    <a target=\"_blank\" href=\"https://www.tensorflow.org/tutorials/keras/overfit_and_underfit\"><img src=\"https://www.tensorflow.org/images/tf_logo_32px.png\" />View on TensorFlow.org</a>\n",
        "  </td>\n",
        "  <td>\n",
        "    <a target=\"_blank\" href=\"https://colab.research.google.com/github/tensorflow/docs-l10n/blob/master/site/vi/tutorials/keras/overfit_and_underfit.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />Run in Google Colab</a>\n",
        "  </td>\n",
        "  <td>\n",
        "    <a target=\"_blank\" href=\"https://github.com/tensorflow/docs-l10n/blob/master/site/vi/tutorials/keras/overfit_and_underfit.ipynb\"><img src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" />View source on GitHub</a>\n",
        "  </td>\n",
        "  <td>\n",
        "    <a href=\"https://storage.googleapis.com/tensorflow_docs/docs-l10n/site/vi/tutorials/keras/overfit_and_underfit.ipynb\"><img src=\"https://www.tensorflow.org/images/download_logo_32px.png\" />Download notebook</a>\n",
        "  </td>\n",
        "</table>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text"
      },
      "source": [
        "**Lưu ý:** Cộng đồng TensorFlow tại Việt Nam đã và đang dịch những tài liệu này từ nguyên bản tiếng Anh.\n",
        "Những bản dịch này được hoàn thiện dựa trên sự nỗ lực đóng góp từ cộng đồng lập trình viên sử dụng TensorFlow,\n",
        "và có thể không đảm bảo được tính cập nhật của bản dịch đối với [Tài liệu chính thức bằng tiếng Anh](https://www.tensorflow.org/?hl=en) này.\n",
        "Nếu bạn có bất kỳ đề xuất nào nhằm cải thiện bản dịch này, vui lòng tạo Pull request đến \n",
        "kho chứa trên GitHub của [tensorflow/docs-l10n](https://github.com/tensorflow/docs-l10n). \n",
        "Để đăng ký dịch hoặc cải thiện nội dung bản dịch, các bạn hãy liên hệ và đặt vấn đề tại \n",
        "[docs-vi@tensorflow.org](https://groups.google.com/a/tensorflow.org/forum/#!forum/docs-vi)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "19rPukKZsPG6"
      },
      "source": [
        "Như thường lệ, code trong ví dụ này dùng API `tf.keras`, các bạn có thể đọc thêm trong TensorFlow [Keras guide](../../guide/keras.ipynb).\n",
        "\n",
        "Trong cả hai ví dụ trước - phân loại bình luận phim và dự đoán độ hiệu quả về năng lượng - chúng ta thấy rằng độ chính xác của các mô hình trong việc thẩm định dữ liệu sẽ đạt đỉnh sau khi huấn luyện qua một số giai đoạn, sau đó sẽ bắt đầu giảm.\n",
        "\n",
        "Nói theo cách khác, các mô hình sẽ trở thành *overfitting* với dữ liệu huấn luyện. Tìm cách để xử lý *overfitting* rất quan trọng. Mặc dù việc đạt được độ chính xác cao cho tập huấn luyện là có thể, điều mà chúng ta thực sự mong muốn là phát triển những mô hình mà tổng quát hoá tốt thành một *tập kiểm thử* (hoặc dữ liệu mà những mô hình chưa thấy bao giờ).\n",
        "\n",
        "Đối lập với quá khớp là *underfitting*. Underfitting xảy ra khi vẫn còn có thể cải thiện dữ liệu kiểm tra. Một số lý do hiện tượng này xảy ra: Nếu mô hình chưa đủ mạnh, hoặc bị chính quy hoá quá mức, hoặc đơn giản là chưa được huấn luyện đủ lâu. Điều này có nghĩa là mạng neuron chưa học đủ những xu huớng liên quan trong tập huấn luyện.\n",
        "\n",
        "Nếu bạn huấn luyện quá lâu, các mô hình sẽ bắt đầu gặp hiện tượng overfitting và học các xu hướng trong tập huấn luyện mà không được tổng quát hoá trong tập kiểm tra. Chúng ta cần giữ cân bằng. Một trong những kĩ năng hữu ích là hiểu làm thế nào để huấn luyện trong số lượng giai đoạn phù hợp.\n",
        "\n",
        "Để phòng ngừa hiện tượng overfitting, phương án tốt nhất là sử dụng thêm dữ liệu huấn luyện. Một mô hình được huấn luyện trên nhiều dữ liệu hơn tự nhiên sẽ được tổng quát hoá tốt hơn. Khi việc mở rộng dữ liệu huấn luyện là không thể nữa, phương án tốt tiếp theo là sử dụng cách kĩ thuật như là chính quy hoá. Việc này đặt ra những giới hạn cho số lượng và loại thông tin mà mô hình của bạn có thể lưu trữ. Nếu một mạng neuron chỉ có thể lưu trữ một số lượng nhỏ những xu hướng, quá trình tối ưu hoá sẽ bắt buộc nó phải tập trung vào những xu hướng nổi trội nhất, và tăng khả năng tổng quát hoá tốt hơn.\n",
        "\n",
        "Trong notebook này, chúng ta sẽ khám phá hai kĩ thuật chính quy hoá phổ biến - chính quy hoá trọng số và dropout - và dùng chúng để cải thiện notebook về phân loại bình luận phim IMDB.   "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "5pZ8A2liqvgk"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "print(tf.__version__)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "1cweoTiruj8O"
      },
      "source": [
        "## Tải tập dữ liệu IMDB\n",
        "\n",
        "Thay vì sử dụng một embedding như trong notebook trước, ở đây chúng ta sẽ multi-hot encode các câu bình luận. Mô hình này sẽ nhanh chóng overfit tập huấn luyện, từ đó trình diễn được việc khi nào thì overfitting xảy ra, và làm thế nào để xử lý nó. \n",
        "\n",
        "Multi-hot-encoding các danh sách có nghĩa là biến chúng trở thành các vectors của 0 và 1. Nói ngắn gọn, việc này biến các chuỗi `[3, 5]` trở thành một vector với 10,000 chiều đều bằng 0 ngoại trừ các chỉ số 3 và 5 sẽ là 1. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "QpzE4iqZtJly"
      },
      "outputs": [],
      "source": [
        "NUM_WORDS = 10000\n",
        "\n",
        "(train_data, train_labels), (test_data, test_labels) = keras.datasets.imdb.load_data(num_words=NUM_WORDS)\n",
        "\n",
        "def multi_hot_sequences(sequences, dimension):\n",
        "    # Create an all-zero matrix of shape (len(sequences), dimension)\n",
        "    results = np.zeros((len(sequences), dimension))\n",
        "    for i, word_indices in enumerate(sequences):\n",
        "        results[i, word_indices] = 1.0  # set specific indices of results[i] to 1s\n",
        "    return results\n",
        "\n",
        "\n",
        "train_data = multi_hot_sequences(train_data, dimension=NUM_WORDS)\n",
        "test_data = multi_hot_sequences(test_data, dimension=NUM_WORDS)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "MzWVeXe3NBTn"
      },
      "source": [
        "Hãy nhìn vào một vector trong những multi-hot vectors kết quả. Các chỉ số từ được sắp xếp bằng tần số, nên có thể kì vọng rằng sẽ có giá trị 1 gần chỉ số 0, như chúng ta thấy trong plot sau:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "71kr5rG4LkGM"
      },
      "outputs": [],
      "source": [
        "plt.plot(train_data[0])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "lglk41MwvU5o"
      },
      "source": [
        "## Trình diễn Overfitting\n",
        "\n",
        "Cách đơn giản nhất để ngăn chặn overfitting là giảm kích thước của mô hình, ví dụ, số lượng tham số có thể học được trong mô hình (được xác định bởi số lớp và số đơn vị trên mỗi lớp). Trong học sâu, số lượng tham số có thể học được trong một mô hình thường được gọi là \"năng lực\" của mô hình. Theo trực giác, một mô hình có nhiều tham số sẽ có nhiều \"khả năng ghi nhớ\" hơn và do đó sẽ có thể dễ dàng học được một ánh xạ giống như từ điển hoàn hảo giữa các mẫu huấn luyện và các mục tiêu của chúng, một ánh xạ không có sức mạnh khái quát hóa, nhưng điều này sẽ vô dụng khi đưa ra dự đoán trên dữ liệu chưa từng thấy trước đây.\n",
        "\n",
        "Chúng ta cần luôn ghi nhớ điều này: các mô hình học sâu có xu hướng phù hợp với dữ liệu đào tạo, nhưng thách thức thực sự là khái quát hóa, không phải chỉ là mô hình phù hợp.\n",
        "\n",
        "Mặt khác, nếu mạng neuron có tài nguyên ghi nhớ hạn chế, nó sẽ không thể học được ánh xạ một cách dễ dàng. Để giảm thiểu tổn thất của nó, nó sẽ phải học các biểu diễn nén có sức mạnh dự đoán nhiều hơn. Đồng thời, nếu bạn làm cho mô hình của mình quá nhỏ, nó sẽ gặp khó khăn khi phù hợp với dữ liệu đào tạo. Cần phải có sự cân bằng giữa \"quá nhiều năng lực\" và \"không đủ năng lực\".\n",
        "\n",
        "Thật không may, không có công thức kỳ diệu nào để xác định kích thước hoặc kiến trúc phù hợp của mô hình của bạn (về số lượng lớp hoặc kích thước phù hợp cho mỗi lớp). Bạn sẽ phải thử nghiệm bằng cách sử dụng một loạt các kiến trúc khác nhau.\n",
        "\n",
        "Để tìm kích thước mô hình phù hợp, tốt nhất là bắt đầu với tương đối ít lớp và tham số, sau đó bắt đầu tăng kích thước của các lớp hoặc thêm các lớp mới cho đến khi bạn thấy giá trị giảm dần của các tổn thất từ thẩm định. Hãy thử điều này trên mạng phân loại đánh giá phim của chúng ta.\n",
        "\n",
        "Chúng ta sẽ tạo một mô hình đơn giản chỉ sử dụng các lớp ```Dense``` làm đường cơ sở, sau đó tạo các phiên bản nhỏ hơn và lớn hơn và so sánh chúng."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "_ReKHdC2EgVu"
      },
      "source": [
        "### Tạo một mô hình cơ sở"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "QKgdXPx9usBa"
      },
      "outputs": [],
      "source": [
        "baseline_model = keras.Sequential([\n",
        "    # `input_shape` is only required here so that `.summary` works.\n",
        "    keras.layers.Dense(16, activation='relu', input_shape=(NUM_WORDS,)),\n",
        "    keras.layers.Dense(16, activation='relu'),\n",
        "    keras.layers.Dense(1, activation='sigmoid')\n",
        "])\n",
        "\n",
        "baseline_model.compile(optimizer='adam',\n",
        "                       loss='binary_crossentropy',\n",
        "                       metrics=['accuracy', 'binary_crossentropy'])\n",
        "\n",
        "baseline_model.summary()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "LqG3MXF5xSjR"
      },
      "outputs": [],
      "source": [
        "baseline_history = baseline_model.fit(train_data,\n",
        "                                      train_labels,\n",
        "                                      epochs=20,\n",
        "                                      batch_size=512,\n",
        "                                      validation_data=(test_data, test_labels),\n",
        "                                      verbose=2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "L-DGRBbGxI6G"
      },
      "source": [
        "### Tạo một mô hình nhỏ hơn"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "SrfoVQheYSO5"
      },
      "source": [
        "Hãy tạo một mô hình với ít các đơn vị ẩn hơn để so sánh với mô hình cơ sở mà chúng ta vừa tạo:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "jksi-XtaxDAh"
      },
      "outputs": [],
      "source": [
        "smaller_model = keras.Sequential([\n",
        "    keras.layers.Dense(4, activation='relu', input_shape=(NUM_WORDS,)),\n",
        "    keras.layers.Dense(4, activation='relu'),\n",
        "    keras.layers.Dense(1, activation='sigmoid')\n",
        "])\n",
        "\n",
        "smaller_model.compile(optimizer='adam',\n",
        "                      loss='binary_crossentropy',\n",
        "                      metrics=['accuracy', 'binary_crossentropy'])\n",
        "\n",
        "smaller_model.summary()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "jbngCZliYdma"
      },
      "source": [
        "Và huấn luyện mô hình sử dụng cùng một dữ liệu: "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "Ofn1AwDhx-Fe"
      },
      "outputs": [],
      "source": [
        "smaller_history = smaller_model.fit(train_data,\n",
        "                                    train_labels,\n",
        "                                    epochs=20,\n",
        "                                    batch_size=512,\n",
        "                                    validation_data=(test_data, test_labels),\n",
        "                                    verbose=2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "vIPuf23FFaVn"
      },
      "source": [
        "### Tạo một mô hình lớn hơn\n",
        "\n",
        "Như một bài tập, bạn có thể tạo ra một mô hình thậm chí còn lớn hơn và xem nó bắt đầu overfitting nhanh như thế nào. Tiếp theo, hãy thêm vào điểm chuẩn này một mạng neuron có dung lượng lớn hơn nhiều, nhiều hơn so với vấn đề sẽ đảm bảo: "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "ghQwwqwqvQM9"
      },
      "outputs": [],
      "source": [
        "bigger_model = keras.models.Sequential([\n",
        "    keras.layers.Dense(512, activation='relu', input_shape=(NUM_WORDS,)),\n",
        "    keras.layers.Dense(512, activation='relu'),\n",
        "    keras.layers.Dense(1, activation='sigmoid')\n",
        "])\n",
        "\n",
        "bigger_model.compile(optimizer='adam',\n",
        "                     loss='binary_crossentropy',\n",
        "                     metrics=['accuracy','binary_crossentropy'])\n",
        "\n",
        "bigger_model.summary()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "D-d-i5DaYmr7"
      },
      "source": [
        "Và huấn luyện mô hình sử dụng cùng một dữ liệu:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "U1A99dhqvepf"
      },
      "outputs": [],
      "source": [
        "bigger_history = bigger_model.fit(train_data, train_labels,\n",
        "                                  epochs=20,\n",
        "                                  batch_size=512,\n",
        "                                  validation_data=(test_data, test_labels),\n",
        "                                  verbose=2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "Fy3CMUZpzH3d"
      },
      "source": [
        "### Vẽ biểu đồ thiệt hại giữa huấn luyện và thẩm định\n",
        "\n",
        "<!--TODO(markdaoust): This should be a one-liner with tensorboard -->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "HSlo1F4xHuuM"
      },
      "source": [
        "Đường kẻ liền thể hiện độ thiệt hại từ huấn luyện, và đường đứt đoạn thể hiện độ thiệt hại từ thẩm định (nên nhớ rằng: độ thiệt hại từ thẩm định thấp biểu lộ một mô hình tốt hơn). Ở đây, mạng neuron nhỏ hơn bắt đầu overfit chậm hơn mô hình cơ bản (sau 6 epoch thay vì 4) và hiệu suất của nó giảm chậm hơn nhiều khi nó bắt đầu overfit."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "0XmKDtOWzOpk"
      },
      "outputs": [],
      "source": [
        "def plot_history(histories, key='binary_crossentropy'):\n",
        "  plt.figure(figsize=(16,10))\n",
        "\n",
        "  for name, history in histories:\n",
        "    val = plt.plot(history.epoch, history.history['val_'+key],\n",
        "                   '--', label=name.title()+' Val')\n",
        "    plt.plot(history.epoch, history.history[key], color=val[0].get_color(),\n",
        "             label=name.title()+' Train')\n",
        "\n",
        "  plt.xlabel('Epochs')\n",
        "  plt.ylabel(key.replace('_',' ').title())\n",
        "  plt.legend()\n",
        "\n",
        "  plt.xlim([0,max(history.epoch)])\n",
        "\n",
        "\n",
        "plot_history([('baseline', baseline_history),\n",
        "              ('smaller', smaller_history),\n",
        "              ('bigger', bigger_history)])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "Bi6hBhdnSfjA"
      },
      "source": [
        "Nhận thấy rằng mạng neuron lớn hơn bắt đầu overfit gần như ngay lập tức, sau chỉ một epoch, và overfit nghiêm trọng hơn. Năng lực càng mạnh thì mạng neuron càng nhanh có thể lên mô hình cho dữ liệu huấn luyện (dẫn đến độ thiệt hại từ huấn luyện thấp), nhưng càng mẫn cảm với overfitting (dẫn đến sự khác biệt lớn giữa độ thiệt hại từ huấn luyện và thẩm định)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "ASdv7nsgEFhx"
      },
      "source": [
        "## Các chiến lược để ngăn ngừa Overfitting "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "4rHoVWcswFLa"
      },
      "source": [
        "### Thêm điều hoà trọng số\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "kRxWepNawbBK"
      },
      "source": [
        "Có thể bạn đã quen thuộc với nguyên tắc Razor của Occam: Cho hai sự giải thích đối với một việc gì đó, sự giải thích có khả năng đúng nhất thường \"đơn giản\" nhất, với ít giả định nhất. Nguyên tắc này cũng ứng dụng được cho mô hình mạng neuron: Cho vài tập huấn luyện và một mạng kiến trúc, có nhiều tập giá trị trọng số (nhiều mô hình) có thể giải thích dữ liệu, và mô hình đơn giản nhất thường có ít có khả năng overfit hơn các mô hình phức tạp.\n",
        "\n",
        "Một \"mô hình đơn giản\" trong ngữ cảnh này là một mô hình mà sự phân bổ của các giá trị tham số có ít entropy (hoặc một mô hình với ít tham số hơn, như chúng ta thấy trong phần trên). Như vậy một cách phổ biến để giảm overfitting là đặt các hạn chế lên sự phức tạp của mạng neuron, bằng cách bắt các trọng số chỉ được lấy các giá trị nhỏ, qua đó làm sự phân bổ giá trị trọng số được \"điều hoà\" hơn. Phương pháp này được gọi là \"điều hoà trọng số\", và nó được làm bằng việc thêm vào hàm thiệt hại của mạng neuron một chi phí đi liền với trọng số lớn. Chi phí này có hai loại:\n",
        "* [L1 regularization](https://developers.google.com/machine-learning/glossary/#L1_regularization), chi phí thêm vào tỉ lệ thuận với giá trị tuyệt đối của hệ số trọng số (được coi là \"L1 norm\" của các trọng số).\n",
        "* [L2 regularization](https://developers.google.com/machine-learning/glossary/#L2_regularization), chi phí thêm vào tỉ lệ thuận với bình phương của hệ số trọng số (được coi là bình phương \"L2 norm\" của các trọng số). Điều hoà L2 cũng được gọi là trọng số suy vi trong ngữ cảnh của mạng neuron. Đừng để các tên gọi khác nhau đánh lừa bạn: xét về toán học, trọng số suy vi chính là điều hoà L2.\n",
        "\n",
        "Điều hoà L1 thêm sự thưa thớt để làm cho trọng số của vài tham số về zero. Điều hoà L2 bắt phạt trọng số của các tham số mà không làm thưa chúng, đây là một lý do khiến điều hoà L2 phổ biến hơn. \n",
        "\n",
        "Trong `tf.keras`, điều hoà trọng số được thêm vào bằng việc bỏ điều hoà trọng số vào các lớp như các từ khoá. Bây giờ chúng ta hãy thêm điều hoà L2.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "HFGmcwduwVyQ"
      },
      "outputs": [],
      "source": [
        "l2_model = keras.models.Sequential([\n",
        "    keras.layers.Dense(16, kernel_regularizer=keras.regularizers.l2(0.001),\n",
        "                       activation='relu', input_shape=(NUM_WORDS,)),\n",
        "    keras.layers.Dense(16, kernel_regularizer=keras.regularizers.l2(0.001),\n",
        "                       activation='relu'),\n",
        "    keras.layers.Dense(1, activation='sigmoid')\n",
        "])\n",
        "\n",
        "l2_model.compile(optimizer='adam',\n",
        "                 loss='binary_crossentropy',\n",
        "                 metrics=['accuracy', 'binary_crossentropy'])\n",
        "\n",
        "l2_model_history = l2_model.fit(train_data, train_labels,\n",
        "                                epochs=20,\n",
        "                                batch_size=512,\n",
        "                                validation_data=(test_data, test_labels),\n",
        "                                verbose=2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "bUUHoXb7w-_C"
      },
      "source": [
        "```l2(0.001)``` means that every coefficient in the weight matrix of the layer will add ```0.001 * weight_coefficient_value**2``` to the total loss of the network. Note that because this penalty is only added at training time, the loss for this network will be much higher at training than at test time.\n",
        "\n",
        "Here's the impact of our L2 regularization penalty:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "7wkfLyxBZdh_"
      },
      "outputs": [],
      "source": [
        "plot_history([('baseline', baseline_history),\n",
        "              ('l2', l2_model_history)])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "Kx1YHMsVxWjP"
      },
      "source": [
        "As you can see, the L2 regularized model has become much more resistant to overfitting than the baseline model, even though both models have the same number of parameters."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "HmnBNOOVxiG8"
      },
      "source": [
        "### Add dropout\n",
        "\n",
        "Dropout is one of the most effective and most commonly used regularization techniques for neural networks, developed by Hinton and his students at the University of Toronto. Dropout, applied to a layer, consists of randomly \"dropping out\" (i.e. set to zero) a number of output features of the layer during training. Let's say a given layer would normally have returned a vector [0.2, 0.5, 1.3, 0.8, 1.1] for a given input sample during training; after applying dropout, this vector will have a few zero entries distributed at random, e.g. [0, 0.5,\n",
        "1.3, 0, 1.1]. The \"dropout rate\" is the fraction of the features that are being zeroed-out; it is usually set between 0.2 and 0.5. At test time, no units are dropped out, and instead the layer's output values are scaled down by a factor equal to the dropout rate, so as to balance for the fact that more units are active than at training time.\n",
        "\n",
        "In tf.keras you can introduce dropout in a network via the Dropout layer, which gets applied to the output of layer right before.\n",
        "\n",
        "Let's add two Dropout layers in our IMDB network to see how well they do at reducing overfitting:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "OFEYvtrHxSWS"
      },
      "outputs": [],
      "source": [
        "dpt_model = keras.models.Sequential([\n",
        "    keras.layers.Dense(16, activation='relu', input_shape=(NUM_WORDS,)),\n",
        "    keras.layers.Dropout(0.5),\n",
        "    keras.layers.Dense(16, activation='relu'),\n",
        "    keras.layers.Dropout(0.5),\n",
        "    keras.layers.Dense(1, activation='sigmoid')\n",
        "])\n",
        "\n",
        "dpt_model.compile(optimizer='adam',\n",
        "                  loss='binary_crossentropy',\n",
        "                  metrics=['accuracy','binary_crossentropy'])\n",
        "\n",
        "dpt_model_history = dpt_model.fit(train_data, train_labels,\n",
        "                                  epochs=20,\n",
        "                                  batch_size=512,\n",
        "                                  validation_data=(test_data, test_labels),\n",
        "                                  verbose=2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "SPZqwVchx5xp"
      },
      "outputs": [],
      "source": [
        "plot_history([('baseline', baseline_history),\n",
        "              ('dropout', dpt_model_history)])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "gjfnkEeQyAFG"
      },
      "source": [
        "Adding dropout is a clear improvement over the baseline model.\n",
        "\n",
        "To recap: here are the most common ways to prevent overfitting in neural networks:\n",
        "\n",
        "* Get more training data.\n",
        "* Reduce the capacity of the network.\n",
        "* Add weight regularization.\n",
        "* Add dropout.\n",
        "\n",
        "And two important approaches not covered in this guide are data-augmentation and batch normalization."
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [
        "fTFj8ft5dlbS"
      ],
      "name": "overfit_and_underfit.ipynb",
      "private_outputs": true,
      "provenance": [],
      "toc_visible": true,
      "version": "0.3.2"
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}
